//package org.wheel.dao.bak;
//
//import org.wheel.plugins.starter.jdbc.pool.config.DaoFactory;
//import org.wheel.plugins.starter.jdbc.pool.dao.IBaseDao;
//import org.wheel.plugins.toolkit.util.ReflectUtil;
//
//import java.lang.reflect.*;
//
//public class BaseDaoProxy {
//
//    private final DaoFactory baseDaoFactory;
//
//    public BaseDaoProxy(DaoFactory baseDaoFactory) {
//        this.baseDaoFactory = baseDaoFactory;
//    }
//
////    public <T> T getBaseDao(Class<T> daoInterface) {
////        // 为每个DAO接口生成一个独立的BaseDaoImpl实例
////        BaseDaoImpl<?> baseDaoImpl = baseDaoFactory.createBaseDao((Class<?>) daoInterface);
////
////        // 创建一个InvocationHandler
////        InvocationHandler handler = new InvocationHandler() {
////            @Override
////            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
////                // 在这里可以添加额外的逻辑，例如日志、事务管理等
////                System.out.println("调用方法：" + method.getName());
////                // 调用目标对象的方法
////                return method.invoke(baseDaoImpl, args);
////            }
////        };
////
////        // 创建代理对象
////        return (T) Proxy.newProxyInstance(
////                daoInterface.getClassLoader(), // 目标类的类加载器
////                new Class<?>[]{daoInterface}, // 目标类实现的接口
////                handler // InvocationHandler
////        );
////    }
//
//    public <T> IBaseDao<T> getBaseDao(Class<?> daoInterface) {
//        return (IBaseDao<T>) Proxy.newProxyInstance(
//                daoInterface.getClassLoader(),
//                new Class[]{daoInterface},
//                new BaseDaoInvocationHandler<>(daoInterface, baseDaoFactory)
//        );
//    }
//
//    private static class BaseDaoInvocationHandler<T> implements InvocationHandler {
//        private final IBaseDao<T> IBaseDao;
//        private final Class<T> daoInterface;
//        private final DaoFactory baseDaoFactory;
//
//        public BaseDaoInvocationHandler(Class<?> daoInterface, DaoFactory baseDaoFactory) {
//            this.daoInterface = (Class<T>) daoInterface;
//            this.baseDaoFactory = baseDaoFactory;
//            Class<T> entityClass = (Class<T>) getGenericType(daoInterface);
//            if(entityClass != null) {
//                this.IBaseDao = baseDaoFactory.createBaseDao(entityClass);
//            }else{
//                this.IBaseDao = null;
//            }
//        }
//
//        @Override
//        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//            // 处理自定义方法: 不是BaseDao的方法 且 在自定义接口声明，进入自定义方法处理
//            if (!isBaseDaoMethod(method) && method.getDeclaringClass().equals(daoInterface)) {
//                return handleCustomMethod(method, args);
//            }
//            return method.invoke(IBaseDao, args);
//        }
//
//        private Object handleCustomMethod(Method method, Object[] args) throws Throwable {
//            // 解析方法签名，生成 SQL 语句
//            String methodName = method.getName();
//            Class<?>[] parameterTypes = method.getParameterTypes();
//            // 示例：生成 SQL 语句
//            String sql = generateSql(methodName, parameterTypes, args);
//            // 执行 SQL 语句
////            return baseDao.executeSql(sql, args);
//            return method.invoke(IBaseDao, args);
//        }
//
//        private String generateSql(String methodName, Class<?>[] parameterTypes, Object[] args) {
//            // 示例：生成 SQL 语句
//            if (methodName.equals("findAllUserByName")) {
//                return "SELECT * FROM users WHERE name = ?";
//            }
//            // 其他方法的 SQL 生成逻辑
//            return "SELECT * FROM unknown";
//        }
//
//        /**
//         * 获取接口泛型参数
//         * @param interfaceClass 接口类
//         * @return 泛型参数类
//         */
//        public Class<?> getGenericType(Class<?> interfaceClass) {
//            Class<?> result = null;
//            Type[] genericInterfaces = interfaceClass.getGenericInterfaces();
//            for (Type genericInterface : genericInterfaces) {
//                if (genericInterface instanceof ParameterizedType) {
//                    ParameterizedType parameterizedType = (ParameterizedType) genericInterface;
//                    Type[] typeArguments = parameterizedType.getActualTypeArguments();
//                    for (Type typeArgument : typeArguments) {
//                        if (typeArgument instanceof Class clazz) {
////                            System.out.println("Type argument: " + typeArgument.getTypeName());
//                            result = clazz;
//                            break;
//                        }
//                    }
//                }
//            }
//            return result;
//        }
//
//        /**
//         * 判断请求的方法是否来自 BaseDao
//         * @param invokeMethod 方法
//         * @return 是否来自 BaseDao
//         */
//        private boolean isBaseDaoMethod(Method invokeMethod) {
//            String methodName = invokeMethod.getName();
//            Class<?>[] parameterTypes = invokeMethod.getParameterTypes();
//            Method method = ReflectUtil.getMethod(IBaseDao.class, methodName, parameterTypes);
//            // 判断方法是否存在
//            if (method != null) {
////                System.out.println("方法 " + methodName + " 存在于接口 " + BaseDao.class.getName());
//                return true;
//            } else {
////                System.out.println("方法 " + methodName + " 不存在于接口 " + BaseDao.class.getName());
//                return false;
//            }
//        }
//    }
//
//}